package xilinx;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;


	   public class Tests {

		private String expresion;
		private String resultado;
		private String obtenido;
	    private InterfazJFrame prueba;
	    
	    @Before
	        public void setUp() throws Exception {
			prueba = new InterfazJFrame();
		}
		
		
	        
	        
	        

		public void tearDown() throws Exception {
			prueba = null;
		}
		@Test
	    public void test1() 
	    {
            expresion= "+CIN";
            resultado="000 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            System.out.println(obtenido);
			assertEquals(resultado, obtenido);
	               
		}

		@Test
		public void test1b() 
	    {
            expresion="-CIN";
            resultado="000 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}


		@Test
	    public void test2() 
		{
            expresion= "(P + CIN)";
            resultado="000 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido) ;
		}

		@Test
	    public void test2b() 
		{
            expresion= "-(P + CIN)";
            resultado="000 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido) ;
		}
		
		
		
		@Test
		public void test3()
		{
            expresion="(A:B + CIN)";
            resultado="000 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test3b()
		{
            expresion="-(A:B + CIN)";
            resultado="000 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		
		
		
		@Test
		public void test4() 
		{
            expresion="(AxB + CIN)";
            resultado="000 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
		public void test4b() 
		{
            expresion="-(AxB + CIN)";
            resultado="000 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
	    public void test5() 
		{
            expresion= "(C + CIN)";
            resultado="000 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
	    public void test5b() 
		{
            expresion= "-(C + CIN)";
            resultado="000 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test
		public void test6()
		{
            expresion="(C + P + CIN)";
            resultado="000 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test
		public void test6b()
		{
            expresion="-(C + P + CIN)";
            resultado="000 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
	        
	        
	        
		@Test    
	    public void test7() 
		{
            expresion= "(A:B + C + CIN)";
            resultado="000 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
	    public void test7b() 
		{
            expresion= "-(A:B + C + CIN)";
            resultado="000 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test    
        public void test8()
		{
            expresion= "PCIN + CIN";
            resultado="001 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test    
        public void test8b()
		{
            expresion= "PCIN - CIN";
            resultado="001 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		@Test
		public void test9()
		{
            expresion="PCIN + (P + CIN)";
            resultado="001 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test9b()
		{
            expresion="PCIN - (P + CIN)";
            resultado="001 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test
		public void test10()
		{
            expresion="PCIN + (A:B + CIN)";
            resultado="001 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		@Test
		public void test10b()
		{
            expresion="PCIN - (A:B + CIN)";
            resultado="001 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
	    public void test11()
		{
            expresion= "PCIN + (AxB + CIN)";
            resultado="001 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		@Test
	    public void test11b()
		{
            expresion= "PCIN - (AxB + CIN)";
            resultado="001 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test12()
		{
            expresion="PCIN + (C + CIN)";
            resultado="001 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		@Test
		
		public void test12b()
		{
            expresion="PCIN - (C + CIN)";
            resultado="001 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test13()
		{
            expresion="PCIN + (C + P + CIN)";
            resultado="001 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test13b()
		{
            expresion="PCIN - (C + P + CIN)";
            resultado="001 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
	    public void test14()
		{
            expresion= "PCIN + (A:B + C + CIN)";
            resultado="001 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
	    public void test14b()
		{
            expresion= "PCIN - (A:B + C + CIN)";
            resultado="001 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		

		@Test
		public void test15() 
		{
            expresion="P + CIN";
            resultado="000 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		@Test
		public void test15b() 
		{
            expresion="P - CIN";
            resultado="010 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test16() 
		{
            expresion="P+ (P + CIN)";
            resultado="010 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
		public void test16b() 
		{
            expresion="P- (P + CIN)";
            resultado="010 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
	    
		@Test
	    public void test17() 
		{
            expresion= "P + (A:B + CIN)";
            resultado="010 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
	      
		
		@Test
	    public void test17b() 
		{
            expresion= "P - (A:B + CIN)";
            resultado="010 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		@Test
		public void test18() 
		{
            expresion= "P + (AxB + CIN)";
            resultado="010 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		public void test18b() 
		{
            expresion= "P - (AxB + CIN)";
            resultado="010 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		@Test
		public void test19() 
		{
            expresion="P + (C + CIN)";
            resultado="000 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test19b() 
		{
            expresion="P - (C + CIN)";
            resultado="010 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test20() 
		{
            expresion="P + (C + P + CIN)";
            resultado="010 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		
		
		@Test
		public void test20b() 
		{
            expresion="P - (C + P + CIN)";
            resultado="010 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test21()
		{
            expresion="P + (A:B + C + CIN)";
            resultado="010 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		@Test
		public void test21b()
		{
            expresion="P - (A:B + C + CIN)";
            resultado="010 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
	        
	        
	        
		@Test    
	    public void test22() 
		{
            expresion= "C + CIN";
            resultado="000 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test    
	    public void test22b() 
		{
            expresion= "C - CIN";
            resultado="011 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test
		public void test23() 
		{
            expresion="C+ (P + CIN)";
            resultado="000 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);

		}
		
		@Test
		public void test23b() 
		{
            expresion="C- (P + CIN)";
            resultado="011 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test
		public void test24() 
		{
            expresion="C + (A:B + CIN)";
            resultado="000 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test24b() 
		{
            expresion="C - (A:B + CIN)";
            resultado="011 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
	    public void test25() 
		{
            expresion= "C + (AxB + CIN)";
            resultado="011 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
	    public void test25b() 
		{
            expresion= "C - (AxB + CIN)";
            resultado="011 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
		public void test26()
		{
            expresion="C + (C + CIN)";
            resultado="011 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test26b()
		{
            expresion="C - (C + CIN)";
            resultado="011 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
		public void test27() 
		{
            expresion="C + (C + P + CIN)";
            resultado="011 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test27b() 
		{
            expresion="C - (C + P + CIN)";
            resultado="011 11 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test    
	    public void test28()
		{
            expresion= "C + (A:B + C + CIN)";
            resultado="011 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}  
	        
	        
		@Test    
	    public void test28b()
		{
            expresion= "C - (A:B + C + CIN)";
            resultado="011 11 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
	        
		@Test    
	    public void test29() 
		{
            expresion= "Shift[PCIN] + CIN";
            resultado="101 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
        	assertEquals(resultado, obtenido);
		}    
		
		
		@Test    
	    public void test29b() 
		{
            expresion= "Shift[PCIN] - CIN";
            resultado="101 00 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
        	assertEquals(resultado, obtenido);
		}

		@Test
		public void test30() 
		{
            expresion="Shift[PCIN] + (P + CIN)";
            resultado="101 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		@Test
		public void test30b() 
		{
            expresion="Shift[PCIN] - (P + CIN)";
            resultado="101 00 10";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}

		@Test
		public void test31()
		{
            expresion="Shift[PCIN] + (A:B + CIN)";
            resultado="101 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test31b()
		{
            expresion="Shift[PCIN] - (A:B + CIN)";
            resultado="101 00 11";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		@Test
        public void test32() 
		{
            expresion= "Shift[PCIN] + (AxB + CIN)";
            resultado="101 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
		
		
		@Test
        public void test32b() 
		{
            expresion= "Shift[PCIN] - (AxB + CIN)";
            resultado="101 01 01";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
            assertEquals(resultado, obtenido);
		}
	
		@Test
		public void test33()
		{
            expresion="Shift[PCIN] + (C + CIN)";
            resultado="101 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test33b()
		{
            expresion="Shift[PCIN] - (C + CIN)";
            resultado="101 11 00";
            System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
		public void test34()
		{ 
            expresion="Shift[PCIN] + (C + P + CIN)";
			resultado="101 11 10";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test34b()
		{ 
            expresion="Shift[PCIN] - (C + P + CIN)";
			resultado="101 11 10";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
        public void test35() 
		{
			expresion= "Shift[PCIN] + (A:B + C + CIN)";
			resultado="101 11 11";
			System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
        public void test35b() 
		{
			expresion= "Shift[PCIN] - (A:B + C + CIN)";
			resultado="101 11 11";
			System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		@Test
		public void test36() 
		{
            expresion="Shift[P] + CIN";
			resultado="110 00 00";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
		public void test36b() 
		{
            expresion="Shift[P] - CIN";
			resultado="110 00 00";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test37() 
		{
            expresion="Shift[P] + (P + CIN)";
			resultado="110 00 10";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		@Test
		public void test37b() 
		{
            expresion="Shift[P] - (P + CIN)";
			resultado="110 00 10";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

	        
		@Test    
        public void test38() 
		{
            expresion= "Shift[P] + (A:B + CIN)";
			resultado="110 00 11";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
	        
		@Test    
        public void test38b() 
		{
            expresion= "Shift[P] - (A:B + CIN)";
			resultado="110 00 11";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
	    
		
		@Test
    	public void test39() 
		{
            expresion= "Shift[P] + (AxB + CIN)";
			resultado="110 01 01";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
    	public void test39b() 
		{
            expresion= "Shift[P] - (AxB + CIN)";
			resultado="110 01 01";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		@Test
		public void test40() 
		{
            expresion="Shift[P] + (C + CIN)";
			resultado="110 11 00";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		@Test
		public void test40b() 
		{
            expresion="Shift[P] - (C + CIN)";
			resultado="110 11 00";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);;
		}
		@Test
		public void test41()
		{
            expresion="Shift[P] + (C + P + CIN)";
			resultado="110 11 10";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		@Test
		public void test41b()
		{
            expresion="Shift[P] - (C + P + CIN)";
			resultado="110 11 10";
			 System.out.println(expresion);
            obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		
		@Test
		public void test42() 
		{
	        expresion= "Shift[P] + (A:B + C + CIN)";
			resultado="110 11 11";
			 System.out.println(expresion);
	        obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}
		@Test
		public void test42b() 
		{
	        expresion= "Shift[P] - (A:B + C + CIN)";
			resultado="110 11 11";
			 System.out.println(expresion);
	        obtenido=prueba.comprobarOPEMODE(expresion);
			assertEquals(resultado, obtenido);
		}

		
	}

